home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / viewers / polyview / plyvw102.lha / PolyView1.02 / args.c < prev    next >
C/C++ Source or Header  |  1990-11-13  |  9KB  |  306 lines
  1. /*
  2.  * National Center for Supercomputing Applications, University of Illinois
  3.  *
  4.  * This NCSA software product is public domain software.  Permission
  5.  * is hereby granted to do whatever you like with it. Should you wish
  6.  * to make a contribution towards the production of this software, please
  7.  * send us your comments about your experience with the software,  why
  8.  * you liked or disliked it, how you use it, and most importantly, how it
  9.  * helps your work. We will receive your comments at softdev@ncsa.uiuc.edu.
  10.  *
  11.  * Please send bug reports to bugs@ncsa.uiuc.edu
  12.  *
  13.  *    Author:        Brian Calvert, NCSA
  14.  *            bcalvert@ncsa.uiuc.edu
  15.  */
  16.  
  17. /*
  18.  *      File:           args.c
  19.  *      Contents:       Command-line arguments processing routines.
  20.  */
  21.  
  22.  
  23. /* INCLUDE FILES */
  24.  
  25. #include <stdio.h>
  26. #include "args.h"
  27.  
  28.  
  29. /**********************************************************************
  30. *  Function    :    args_found_arg
  31. *  Purpose    :    checks if a given argument is present
  32. *  Parameters    :    args        table of arguments
  33. *            switchname    name of argument to check for
  34. *  Returns    :    TRUE if present, FALSE otherwise
  35. *  Calls    :    none
  36. *  Called by    :    none
  37. **********************************************************************/
  38. int
  39. args_found_arg(args, switchname)
  40.     args_t args[];
  41.     char * switchname;
  42. {
  43.     args_t * arg;
  44.  
  45.     /* Search until we find the switch, then return its "found" value */
  46.     for (arg=args; arg->switchname != NULL; arg++) {
  47.         if (strcmp(switchname, arg->switchname) == 0)
  48.             return (arg->found);
  49.     }
  50.  
  51.     /* If we didn't find the switch, return FALSE */
  52.     return FALSE;
  53. }
  54.  
  55.  
  56. /**********************************************************************
  57. *  Function     :       args_usage
  58. *  Purpose      :       prints a "usage" message using the args table data
  59. *  Parameters   :       argv            command line arguments
  60. *                       args        table of arguments
  61. *  Returns      :       FALSE
  62. *  Calls        :       none
  63. *  Called by    :       args_parse
  64. **********************************************************************/
  65. int
  66. args_usage(argv, args)
  67.     char * argv[];
  68.     args_t args[];
  69. {
  70.     int i, j;
  71.     static char * argtype[] = {"", " <int>", " <float>", " <string>"};
  72.  
  73.     /* Print the usage header, name of the program, and then one */
  74.     /* switch per line. */
  75.     printf("usage:\t%s\n", argv[0]);
  76.     for(i=0; args[i].switchname != NULL; i++) {
  77.         /* Print the switchname.  Place a bracket in front of it */
  78.         /* if it is optional. */
  79.         printf("\t%c-%s",args[i].mandatory ? '\0' : '[',
  80.                  args[i].switchname);
  81.  
  82.         for(j=args[i].size; j>0; j--) {
  83.             printf(argtype[args[i].type]);
  84.             if (args[i].type == STRING) break;
  85.         }
  86.  
  87.         /* Optionally print a closing bracket. */
  88.         printf("%c\n",args[i].mandatory ? '\0' : ']');
  89.     }
  90.  
  91.     /* Print the descriptions of the switches */
  92.     printf("where:");
  93.     for(i=0; args[i].switchname != NULL; i++) {
  94.         printf("\t\"%s\" %s\n", args[i].switchname,
  95.                     args[i].description);
  96.     }
  97.  
  98.     return FALSE;
  99. }
  100.  
  101.  
  102. /**********************************************************************
  103. *  Function     :       args_dump_args
  104. *  Purpose      :       "dumps" all of the arguments in the table
  105. *  Parameters   :    args        table of arguments
  106. *  Returns      :       FALSE
  107. *  Calls        :       args_dump_arg
  108. *  Called by    :       none
  109. **********************************************************************/
  110. int
  111. args_dump_args(args)
  112.     args_t args[];
  113. {
  114.     int i;
  115.  
  116.     /* Dump the contents of the switch table */
  117.     for (i=0; args[i].switchname != NULL; i++) {
  118.         args_dump_arg(args,i);
  119.     }
  120.  
  121.     return FALSE;
  122. }
  123.  
  124.  
  125. /**********************************************************************
  126. *  Function     :       args_dump_arg
  127. *  Purpose      :       prints the contents of one element of the args table
  128. *  Parameters   :       args            table of arguments
  129. *            i        the argument to print
  130. *  Returns      :       TRUE if bad argument number, FALSE otherwise
  131. *  Calls        :       none
  132. *  Called by    :       args_dump_args
  133. **********************************************************************/
  134. static int
  135. args_dump_arg(args,i)
  136.     args_t args[];
  137.     int i;
  138. {
  139.     static char * typename[] = {"BOOLEAN", "INT", "FLOAT", "STRING"};
  140.  
  141.     /* Quit if the switchname is null. */
  142.     if (args[i].switchname == NULL) {
  143.         printf("Bad switch table number.\n");
  144.         return TRUE;
  145.     }
  146.  
  147.     /* Print the information that can be done without much processing */
  148.     printf("\nSwitchname:\t%s",args[i].switchname);
  149.     printf("\n  Mandatory:\t%s",(args[i].mandatory ? "YES" : "NO"));
  150.     printf("\n  Size:\t\t%d",args[i].size);
  151.     printf("\n  Type:\t\t%s",typename[args[i].type]);
  152.     printf("\n  Value:\t");
  153.  
  154.     /* Format the value of the switch appropriately */
  155.     switch(args[i].type) {
  156.     case BOOLEAN:
  157.         printf("%s",(*((int *)args[i].value) ? "TRUE" : "FALSE"));
  158.         break;
  159.     case INT:
  160.         printf("%d",*((int *)args[i].value));
  161.         break;
  162.     case FLOAT:
  163.         printf("%f",*((float *)args[i].value));
  164.         break;
  165.     case STRING:
  166.         printf("%s",args[i].value);
  167.         break;
  168.     }
  169.  
  170.     /* Finally, some more information that needs little processing */
  171.     printf("\n  Found:\t%s",(args[i].found ? "YES" : "NO"));
  172.     printf("\n  Description:\t%s\n",args[i].description);
  173.  
  174.     return FALSE;
  175. }
  176.  
  177.  
  178. /**********************************************************************
  179. *  Function     :       args_parse
  180. *  Purpose      :       prints the contents of one element of the args table
  181. *  Parameters   :       argc        number of arguments
  182. *            argv        command line arguments
  183. *            args            table of arguments
  184. *  Returns      :       TRUE if bad argument number, FALSE otherwise
  185. *  Calls        :       args_parse_value, args_usage
  186. *  Called by    :       args_dump_args
  187. **********************************************************************/
  188. int
  189. args_parse(argc, argv, args)
  190.     int argc;
  191.     char * argv[];
  192.     args_t args[];
  193. {
  194.     int i, j;
  195.     int found, error;
  196.  
  197.     /* Parse all of the arguments on the command-line */
  198.     for(i=1; i<argc; i++) {
  199.         found = FALSE;
  200.         error = FALSE;
  201.  
  202.         for (j=0; (!found && (args[j].switchname != NULL)); j++) {
  203.             if (strcmp(args[j].switchname,&argv[i][1]) == 0) {
  204.                 /* We have a match.  Parse the following */
  205.                 /* arguments as required. */
  206.                 error = args_parse_value(argc,argv,args,&i,j);
  207.  
  208.                 /* Set the "found" flag */
  209.                 found = TRUE;
  210.             }
  211.         }
  212.  
  213.         /* If an error occurred, or the flag was not found, print */
  214.         /* the usage */
  215.         if (!found || error) {
  216.             if (!found)
  217.                 printf("ERROR:  %s not a valid switch.\n",
  218.                        argv[i]);
  219.             args_usage(argv,args);
  220.             exit(-1);
  221.         }
  222.     }
  223.  
  224.     /* Confirm that all required switches were found */
  225.     for (j=0; args[j].switchname != NULL; j++) {
  226.         if ( (args[j].mandatory) && (!args[j].found) ) {
  227.             printf("ERROR:  -%s is required.\n",args[j].switchname);
  228.             args_usage(argv,args);
  229.             exit(-1);
  230.         }
  231.     }
  232.  
  233.     return FALSE;
  234. }
  235.  
  236.  
  237.  
  238. /**********************************************************************
  239. *  Function     :       args_parse_value
  240. *  Purpose      :       parses the given switch and updates the args table
  241. *  Parameters   :       argc            number of arguments
  242. *                       argv            command line arguments
  243. *                       args            table of arguments
  244. *            arg_num        argument number to parse (modified)
  245. *            table_num    entry in args table to parse into
  246. *  Returns      :       TRUE if error, FALSE otherwise
  247. *  Calls        :       none
  248. *  Called by    :       args_parse
  249. **********************************************************************/
  250. static int
  251. args_parse_value(argc, argv, args, arg_num, table_num)
  252.     int argc;
  253.     char * argv[];
  254.     args_t args[];
  255.     int * arg_num;
  256.     int table_num;
  257. {
  258.     int i, j;
  259.  
  260.  
  261.     /* If the switch has already been processed, return an error */
  262.     if (args[table_num].found)
  263.         return TRUE;
  264.  
  265.     /* Determine which type of switch was encountered and parse */
  266.     /* accordingly */
  267.     switch (args[table_num].type) {
  268.     case BOOLEAN:
  269.         *(args[table_num].value) = !*(args[table_num].value);
  270.         break;
  271.     case INT:
  272.         /* Read all of the elements we require into the array */
  273.         for(j=args[table_num].size, i=0; j > 0; j--, i++) {
  274.             (*arg_num)++;
  275.             sscanf(argv[*arg_num], "%d", 
  276.                    ((int *)args[table_num].value)+i);
  277.         }
  278.         break;
  279.     case FLOAT:
  280.         /* Read all of the elements we require into the array */
  281.         for(j=args[table_num].size, i=0; j > 0; j--, i++) {
  282.             (*arg_num)++;
  283.             sscanf(argv[*arg_num], "%f", 
  284.                    ((float *)args[table_num].value)+i);
  285.         }
  286.         break;
  287.     case STRING:
  288.         /* Copy the string into the data value area */
  289.         (*arg_num)++;
  290.         strncpy((char *)args[table_num].value,argv[*arg_num],
  291.             args[table_num].size);
  292.         *(((char *) args[table_num].value)+args[table_num].size-1) =
  293.             '\0';
  294.         break;
  295.     default:
  296.         printf("ERROR:  Switch type %d undefined.\n",
  297.                args[table_num].type);
  298.         return TRUE;
  299.     }
  300.  
  301.     /* If we got this far, everything went fine.  Set found to TRUE for */
  302.     /* the current switch and return FALSE (no error) */
  303.     args[table_num].found = TRUE;
  304.     return FALSE;
  305. }
  306.